package Buildings.dwelling;
import Interfaces.*;
import java.util.*;

public class DwellingFloor implements Floor, java.io.Serializable, Cloneable {

    //private Space flatsInOneFloor[];
    private  List <Space> massive;
    
    //внутренний класс итератора
    /*private class myIterator implements Iterator {

        private int index = -1;
        public boolean hasNext() {
            return index + 1 < getHowMuchSpaceInFloor();
        }
        public Space next() {
            index += 1;
            if (index < flatsInOneFloor.length) {
                return flatsInOneFloor[index];
            } else {
                return null;
            }
        }
        public void remove() {
            throw new UnsupportedOperationException();
        }
    }*/
    @Override
    public java.util.Iterator iterator() {
        //return new myIterator();
        return massive.iterator();
    }
    @Override
    public int getHowMuchSpaceInFloor() {
        //return flatsInOneFloor.length;
        return massive.size();
    }
    @Override
    public double getHowMuchAreaInFloor() {
        /*double s = 0;
        for (int i = 0; i < flatsInOneFloor.length; i++) {
            if (flatsInOneFloor[i] != null) {
                s += flatsInOneFloor[i].getHowMuchArea();
            }
        }
        return s;*/
        double s = 0;
        for(Space x:massive){
            s+=x.getHowMuchArea();
        }
        return s;
        
    }
    @Override
    public int getHowMuchRoomsInFloor() {
        /*int k = 0;
        for (int i = 0; i < flatsInOneFloor.length; i++) {
            if (flatsInOneFloor[i] != null) {
                k += flatsInOneFloor[i].getHowMuchRooms();
            }
        }
        return k;*/
        int k = 0;
        for(Space x:massive){
            k+=x.getHowMuchRooms();
        }
        return k;
    }
    @Override
    public Space[] getMassSpacesInFloor() {
        //return flatsInOneFloor;
        Space []f=new Space[massive.size()];
        int i=0;
        for(Space x:massive){
            f[i]=x;
            i++;
        }
        return f;
    }
    @Override
    public Space getSpaceInFloor(int i) {
        /*if (i >= 0 && i < flatsInOneFloor.length) {
            return flatsInOneFloor[i];
        }
        System.out.println("Неправильный номер!");
        return null; //неправильный номер квартиры*/
        if (i >= 0 && i < massive.size()) {
            int j=0;
            for(Space x: massive){
                if(j==i)return x;
                j++;
            }
        }System.out.println("Неправильный номер!");
        return null;
        
    }
    @Override
    public void setSpaceInFloor(int i, Space s) {
        /*if (i >= 0 && i < flatsInOneFloor.length) {
            flatsInOneFloor[i] = (Space) s.clone();
        } else {
            System.out.println("Неправильный номер!");
        }*/
        if (i >= 0 && i < massive.size()) {
            int j=0;
            for(Space x: massive){
                if(i==j){
                    x =(Space)s.clone();
                    break;
                }
            }
        } else {
            System.out.println("Неправильный номер!");
        }
    }
    @Override
    public void addSpaceInFloor(int i, Space s) {
        if (i >= 0 && i <=massive.size()){
            if(i==massive.size())massive.add(s);
            else massive.add(i, s);
        }else {
            System.out.println("Неправильный номер для этажа!");
        }
        /*if (i >= 0 && i <=flatsInOneFloor.length) {
            Space []newFloor=new Space[flatsInOneFloor.length+1];
            if(i==0){//для начала
                newFloor[0]=(Space)s.clone();
                int k=0;
                for(int j=1;j<newFloor.length;j++,k++){
                    newFloor[j]=flatsInOneFloor[k];
                }
                flatsInOneFloor=newFloor;
                return;
            }
            if(i==flatsInOneFloor.length){//для конца
                for(int j=0;j<flatsInOneFloor.length;j++){
                    newFloor[j]=flatsInOneFloor[j];
                }
                newFloor[i]=(Space)s.clone();
                flatsInOneFloor=newFloor;
                return;
            }
            for(int j=0;j<i;j++){//для середины
                newFloor[j]=flatsInOneFloor[j];
            }
            newFloor[i]=(Space)s.clone();
            int k=i+1;
            for(int j=i;j<flatsInOneFloor.length;j++){
                newFloor[k]=flatsInOneFloor[j];
                k++;
            }
            flatsInOneFloor=newFloor;
        } else {
            System.out.println("Неправильный номер для этажа!");
        }*/
    }
    @Override
    public void delSpaceInFloor(int i) {
        if (i >= 0 && i <massive.size()){
            massive.remove(i);
        } else {
            System.out.println("Неправильный номер! Квартиры с таким номером не существует.");
        }
        /*if (i >= 0 && i <flatsInOneFloor.length) {
            Space []newFloor=new Space[flatsInOneFloor.length-1];
            if(i==0){
                for(int j=1;j<flatsInOneFloor.length;j++){
                    newFloor[j-1]=flatsInOneFloor[j];
                }
                flatsInOneFloor=newFloor;
                return;
            }
            if(i==flatsInOneFloor.length-1){
                for(int j=0;j<flatsInOneFloor.length-1;j++){
                    newFloor[j]=flatsInOneFloor[j];
                }
                flatsInOneFloor=newFloor;
                return;
            }
            for(int j=0;j<i;j++){
                newFloor[j]=flatsInOneFloor[j];
            }
            for(int j=i+1;j<flatsInOneFloor.length;j++){
                newFloor[j]=flatsInOneFloor[j];
            }
            flatsInOneFloor=newFloor;
        } else {
            System.out.println("Неправильный номер! Квартиры с таким номером не существует.");
        }*/
    }
    @Override
    public Space getBestSpace() {
        double s=0;
        Space best=null;
        for(Space x: massive){
            if(x.getHowMuchArea()>s){
                best=x;
                s=best.getHowMuchArea();
            }
        }
        return best;
        /*double s = 0;
        int j = 0;
        for (int i = 0; i < flatsInOneFloor.length; i++) {
                if (s < flatsInOneFloor[i].getHowMuchArea()) {
                    j = i;
                    s = flatsInOneFloor[i].getHowMuchArea();
                }
        }
        if (s != 0) {
            return flatsInOneFloor[j];
        }
        return null;*/
    }
    
    public String toString() {
        StringBuilder s = new StringBuilder();
        s.append(" этаж (жилой) \n");
        for (int i = 0; i < getHowMuchSpaceInFloor(); i++) {
            s.append((getSpaceInFloor(i).toString()));
        }
        s.append("\n");
        return s.toString();
    }
    public boolean equals(Object o) {
        boolean answer = false;
        if (o.getClass() == this.getClass()) {
            if (((DwellingFloor) o).getHowMuchSpaceInFloor() == this.getHowMuchSpaceInFloor()) {
                boolean key = true;
                for (int j = 0; j < getHowMuchSpaceInFloor(); j++) {
                    if (getSpaceInFloor(j).equals(((DwellingFloor) o).getSpaceInFloor(j)) == false) {
                        key = false;
                        break;
                    }
                }
                if (key == true)answer = true;
            }
        }
        return answer;
    }
    public int hashCode() {
        int hash;
        hash = (Integer.bitCount(this.getHowMuchSpaceInFloor()));
        for (int i = 0; i < this.getHowMuchSpaceInFloor(); i++) {
            hash = (int) (hash ^ this.getSpaceInFloor(i).hashCode());
        }
        return hash;
    }
    public Object clone() {
        /*Space []massForClone=new Space[flatsInOneFloor.length];
        for(int i=0;i<flatsInOneFloor.length;i++){
            massForClone[i]=(Space)flatsInOneFloor[i].clone();
        }
        return new DwellingFloor(massForClone);*/
        Space []massForClone=new Space[massive.size()];
        int i=0;
        for(Space x:massive){
            massForClone[i]=(Space)x.clone();
            i++;
        }
        return new DwellingFloor(massForClone);
    }
    //Конструкторы
    public DwellingFloor(int n) {
        /*flatsInOneFloor = new Space[n];
        for (int i = 0; i < n; i++) {
            flatsInOneFloor[i] = new Flat();
        }*/
        massive=new Vector();
        for (int i = 0; i < n; i++) {
            massive.add(new Flat());
        }
    }
    public DwellingFloor(Space...enotherFloor) {
        //для общего случая
        /*flatsInOneFloor = new Space[enotherFloor.length];
        for (int i = 0; i < enotherFloor.length; i++) {
            flatsInOneFloor[i]=enotherFloor[i];//принимаем массив
        }*/
        massive=new Vector();
        for (int i = 0; i < enotherFloor.length; i++) {
            massive.add(enotherFloor[i]);
        }
    }
}